package com.mac.intellect_flow.framework.util;


import cn.hutool.extra.spring.SpringUtil;
import cn.hutool.json.JSONArray;
import com.mac.intellect_flow.constant.CommonConstant;
import com.mac.intellect_flow.framework.dto.SysDictDataDto;
import com.mac.intellect_flow.redis.util.RedisUtil;
import org.apache.commons.lang3.StringUtils;

import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * 字典工具类
 * 
 * @author mac
 */
public class DictUtils {
    /**
     * 分隔符
     */
    public static final String SEPARATOR = ",";

    /**
     * 设置字典缓存
     * 
     * @param key 参数键
     * @param dictDatas 字典数据列表
     */
    public static void setDictCache(String key, List<SysDictDataDto> dictDatas) {
        RedisUtil redisUtil = SpringUtil.getBean(RedisUtil.class);
        redisUtil.setCacheMapValue(getCacheKey(), key,dictDatas);
        redisUtil.expire(getCacheKey(), CommonConstant.CACHE_EXPIRE_DEFAULT, TimeUnit.HOURS);
    }

    /**
     * 获取字典缓存
     * 
     * @param key 参数键
     * @return dictDatas 字典数据列表
     */
    public static List<SysDictDataDto> getDictCache(String key) {
        return SpringUtil.getBean(RedisUtil.class).getCacheMapValue(getCacheKey(),key);
    }

    /**
     * 根据字典类型和字典值获取字典标签
     * 
     * @param dictType 字典类型
     * @param dictValue 字典值
     * @return 字典标签
     */
    public static String getDictLabel(String dictType, String dictValue)
    {
        if (StringUtils.isEmpty(dictValue))
        {
            return StringUtils.EMPTY;
        }
        return getDictLabel(dictType, dictValue, SEPARATOR);
    }

    /**
     * 根据字典类型和字典标签获取字典值
     * 
     * @param dictType 字典类型
     * @param dictLabel 字典标签
     * @return 字典值
     */
    public static String getDictValue(String dictType, String dictLabel)
    {
        if (StringUtils.isEmpty(dictLabel))
        {
            return StringUtils.EMPTY;
        }
        return getDictValue(dictType, dictLabel, SEPARATOR);
    }

    /**
     * 根据字典类型和字典值获取字典标签
     * 
     * @param dictType 字典类型
     * @param dictValue 字典值
     * @param separator 分隔符
     * @return 字典标签
     */
    public static String getDictLabel(String dictType, String dictValue, String separator)
    {
        StringBuilder propertyString = new StringBuilder();
        List<SysDictDataDto> datas = getDictCache(dictType);
        if (Objects.isNull(datas))
        {
            return StringUtils.EMPTY;
        }
        if (StringUtils.containsAny(separator, dictValue))
        {
            for (SysDictDataDto dict : datas)
            {
                for (String value : dictValue.split(separator))
                {
                    if (value.equals(dict.getDictValue()))
                    {
                        propertyString.append(dict.getDictLabel()).append(separator);
                        break;
                    }
                }
            }
        }
        else
        {
            for (SysDictDataDto dict : datas)
            {
                if (dictValue.equals(dict.getDictValue()))
                {
                    return dict.getDictLabel();
                }
            }
        }
        return StringUtils.stripEnd(propertyString.toString(), separator);
    }

    /**
     * 根据字典类型和字典标签获取字典值
     * 
     * @param dictType 字典类型
     * @param dictLabel 字典标签
     * @param separator 分隔符
     * @return 字典值
     */
    public static String getDictValue(String dictType, String dictLabel, String separator)
    {
        StringBuilder propertyString = new StringBuilder();
        List<SysDictDataDto> datas = getDictCache(dictType);
        if (Objects.isNull(datas))
        {
            return StringUtils.EMPTY;
        }
        if (StringUtils.containsAny(separator, dictLabel))
        {
            for (SysDictDataDto dict : datas)
            {
                for (String label : dictLabel.split(separator))
                {
                    if (label.equals(dict.getDictLabel()))
                    {
                        propertyString.append(dict.getDictValue()).append(separator);
                        break;
                    }
                }
            }
        }
        else
        {
            for (SysDictDataDto dict : datas)
            {
                if (dictLabel.equals(dict.getDictLabel()))
                {
                    return dict.getDictValue();
                }
            }
        }
        return StringUtils.stripEnd(propertyString.toString(), separator);
    }

    /**
     * 根据字典类型获取字典所有值
     *
     * @param dictType 字典类型
     * @return 字典值
     */
    public static String getDictValues(String dictType)
    {
        StringBuilder propertyString = new StringBuilder();
        List<SysDictDataDto> datas = getDictCache(dictType);
        if (Objects.isNull(datas))
        {
            return StringUtils.EMPTY;
        }
        for (SysDictDataDto dict : datas)
        {
            propertyString.append(dict.getDictValue()).append(SEPARATOR);
        }
        return StringUtils.stripEnd(propertyString.toString(), SEPARATOR);
    }

    /**
     * 根据字典类型获取字典所有标签
     *
     * @param dictType 字典类型
     * @return 字典值
     */
    public static String getDictLabels(String dictType)
    {
        StringBuilder propertyString = new StringBuilder();
        List<SysDictDataDto> datas = getDictCache(dictType);
        if (Objects.isNull(datas))
        {
            return StringUtils.EMPTY;
        }
        for (SysDictDataDto dict : datas)
        {
            propertyString.append(dict.getDictLabel()).append(SEPARATOR);
        }
        return StringUtils.stripEnd(propertyString.toString(), SEPARATOR);
    }

    /**
     * 删除指定字典缓存
     * 
     * @param key 字典键
     */
    public static void removeDictCache(String key)
    {
        SpringUtil.getBean(RedisUtil.class).deleteCacheMapValue(getCacheKey(),key);
    }

    /**
     * 清空字典缓存
     */
    public static void clearDictCache()
    {
        //Collection<String> keys = SpringUtil.getBean(RedisUtil.class).keys(CommonConstant.SYS_DICT_KEY + "*");
        SpringUtil.getBean(RedisUtil.class).deleteObject(getCacheKey());
    }

    /**
     * 设置cache key
     * 
     * @return 缓存键key
     */
    public static String getCacheKey()
    {
        return CommonConstant.SYS_DICT_KEY + "map";
    }
}
